package com.malou.client.pagos.pagoletras;

import java.util.Date;
import java.util.List;

import com.extjs.gxt.ui.client.data.BaseFilterPagingLoadConfig;
import com.extjs.gxt.ui.client.data.BaseListLoader;
import com.extjs.gxt.ui.client.data.BasePagingLoadConfig;
import com.extjs.gxt.ui.client.data.BasePagingLoader;
import com.extjs.gxt.ui.client.data.BeanModel;
import com.extjs.gxt.ui.client.data.BeanModelReader;
import com.extjs.gxt.ui.client.data.FilterPagingLoadConfig;
import com.extjs.gxt.ui.client.data.ListLoadResult;
import com.extjs.gxt.ui.client.data.ListLoader;
import com.extjs.gxt.ui.client.data.ModelData;
import com.extjs.gxt.ui.client.data.PagingLoadResult;
import com.extjs.gxt.ui.client.data.PagingLoader;
import com.extjs.gxt.ui.client.data.RpcProxy;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.widget.MessageBox;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.malou.client.MalouConstants;
import com.malou.client.MalouMessages;
import com.malou.client.pagos.bancos.Banco;
import com.malou.client.util.MensajeData;
import com.malou.client.util.Utilities;

public class Letras {

	private static LetrasServiceAsync vs = GWT.create(LetrasService.class);
	private static MalouConstants constants = GWT.create(MalouConstants.class);
	private static MalouMessages messages = GWT.create(MalouMessages.class);
	public static PagingLoader<PagingLoadResult<ModelData>> loader;
	public static ListStore<BeanModel> store;

	public static ListStore<BeanModel> storehistorial;
	public static PagingLoader<PagingLoadResult<ModelData>> loaderhistorial;

	public static PagoLetraDialog letraDialog;
	public static RenovarLetraDialog renovarletraDialog;
	public static String filter;
	public static Date desde;
	public static Date hasta;

	public static ListStore<BeanModel> storeBanco;
	public static ListLoader<ListLoadResult<ModelData>> loaderBanco;

	public static void getPaginate() {

		RpcProxy<PagingLoadResult<Letra>> proxy = new RpcProxy<PagingLoadResult<Letra>>() {

			@Override
			protected void load(Object loadConfig,
					AsyncCallback<PagingLoadResult<Letra>> callback) {
				vs.paginateLetrasPendientes(
						(FilterPagingLoadConfig) loadConfig, filter, null,
						null, false, callback);

			}

		};

		loader = new BasePagingLoader<PagingLoadResult<ModelData>>(proxy,
				new BeanModelReader()) {
			@Override
			protected Object newLoadConfig() {
				BasePagingLoadConfig config = new BaseFilterPagingLoadConfig();
				return config;
			}

		};

		loader.setRemoteSort(true);

		store = new ListStore<BeanModel>(loader);
	}

	public static void getPaginateHistorial() {

		RpcProxy<PagingLoadResult<Letra>> proxy = new RpcProxy<PagingLoadResult<Letra>>() {

			@Override
			protected void load(Object loadConfig,
					AsyncCallback<PagingLoadResult<Letra>> callback) {
				vs.paginateLetrasPendientes(
						(FilterPagingLoadConfig) loadConfig, filter, desde,
						hasta, true, callback);
			}

		};

		loaderhistorial = new BasePagingLoader<PagingLoadResult<ModelData>>(
				proxy, new BeanModelReader()) {
			@Override
			protected Object newLoadConfig() {
				BasePagingLoadConfig config = new BaseFilterPagingLoadConfig();
				return config;
			}

		};

		loaderhistorial.setRemoteSort(true);

		storehistorial = new ListStore<BeanModel>(loaderhistorial);
	}

	public static void save(List<Letra> list) {

		vs.save(list, new AsyncCallback<MensajeData>() {

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(),
						constants.errorConexion(), null);
			}

			@Override
			public void onSuccess(MensajeData data) {
				if (data.guardado) {
					loader.load();
					letraDialog.limpiar();
				} else {

					String msg;
					if (data.errorTipo == 1)
						msg = messages.letraYaExisteLetra(data.numero);
					else
						msg = constants.letraNoGuardado();

					MessageBox.alert(constants.sistemaMarcocruzado(), msg, null);
				}
				// letraDialog.status.hide();
				letraDialog.getButtonBar().enable();
			}

		});
	}

	public static void cancelar(Integer id) {

		vs.cancelar(id, new AsyncCallback<MensajeData>() {

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(),
						constants.errorConexion(), null);
			}

			@Override
			public void onSuccess(MensajeData data) {
				if (data.guardado) {
					Integer offset = loader.getOffset();
					loader.load(offset, Utilities.itemsPerPage);
				} else {
					MessageBox.alert(constants.sistemaMarcocruzado(),
							constants.letraNoCancelado(), null);
				}
			}

		});
	}

	public static void getComboBancos() {
		RpcProxy<List<Banco>> proxy = new RpcProxy<List<Banco>>() {

			@Override
			protected void load(Object loadConfig,
					AsyncCallback<List<Banco>> callback) {
				vs.getBancos(callback);
			}

		};

		loaderBanco = new BaseListLoader<ListLoadResult<ModelData>>(proxy,
				new BeanModelReader());

		storeBanco = new ListStore<BeanModel>(loaderBanco);
	}

	public static void edit(Letra l) {

		vs.edit(l, new AsyncCallback<MensajeData>() {

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(),
						constants.errorConexion(), null);
				store.rejectChanges();
			}

			@Override
			public void onSuccess(MensajeData data) {
				if (data.guardado) {
					// letraDialog.clearPrincipal();
					loader.load(0, Utilities.itemsPerPage);
				} else {

					String msg;
					msg = constants.letraNoGuardado();
					MessageBox.alert(constants.sistemaMarcocruzado(), msg, null);
				}
				// letraDialog.status.hide();
				letraDialog.getButtonBar().enable();
			}

		});
	}

	public static void renovar(Integer padre_id, List<Letra> list) {

		vs.renovar(padre_id, list, new AsyncCallback<MensajeData>() {

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(),
						constants.errorConexion(), null);
				// store.rejectChanges();
			}

			@SuppressWarnings("deprecation")
			@Override
			public void onSuccess(MensajeData data) {
				if (data.guardado) {
					// letraDialog.clearPrincipal();
					loader.load();
					renovarletraDialog.reset();
					renovarletraDialog.close();
				} else {

					String msg;
					msg = constants.letraNoGuardado();
					MessageBox.alert(constants.sistemaMarcocruzado(), msg, null);
				}
				// letraDialog.status.hide();
				renovarletraDialog.getButtonBar().enable();
			}

		});
	}

	public static void delete(Integer id) {

		vs.delete(id, new AsyncCallback<MensajeData>() {

			@Override
			public void onSuccess(MensajeData result) {
				if (result.guardado)
					loader.load();
				else {
					String msg;
					msg = constants.letraNoEliminado();
					MessageBox.alert(constants.sistemaMarcocruzado(), msg, null);
				}

			}

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(),
						constants.errorConexion(), null);

			}
		});
	}

	public static void deleteAll(String ids) {

		vs.deleteAll(ids, new AsyncCallback<MensajeData>() {

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(),
						constants.errorConexion(), null);
			}

			@Override
			public void onSuccess(MensajeData data) {
				if (data.guardado) {
					loader.load();
				} else {

					MessageBox.alert(constants.sistemaMarcocruzado(),
							constants.letraNoEliminados(), null);
				}
			}

		});
	}

	

}
